home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / fractal / fracxtr5 / frm / fractint.frm < prev    next >
Text File  |  1993-05-19  |  16KB  |  664 lines
  1. comment {
  2.  FRACTINT.DOC has instructions for adding new formulas to this file.
  3.  There are several hard-coded restrictions in the formula interpreter:
  4.  
  5.  1) The fractal name through the open curly bracket must be on a single line.
  6.  2) There is a hard-coded limit of 200 formulas per formula file, only
  7.     because of restrictions in the prompting routines.
  8.  3) Formulas can containt at most 250 operations (references to variables and
  9.     arithmetic); this is bigger than it sounds, no formula in the default
  10.     fractint.frm uses even 100
  11.  3) Comment blocks can be set up using dummy formulas with no formula name
  12.     or with the special name "comment".
  13.  
  14.  The formulas at the beginning of this file are from Mark Peterson, who
  15.  built this fractal interpreter feature.  The rest are grouped by contributor.
  16.  (Scott Taylor sent many but they are no longer here - they've been
  17.  incorporated as hard-coded types.  Lee Skinner also sent many which have
  18.  now been hard-coded.)
  19.  
  20.  Note that the builtin "cos" function had a bug which was corrected in
  21.  version 16.  To recreate an image from a formula which used cos before
  22.  v16, change "cos" in the formula to "cosxx" which is a new function
  23.  provided for backward compatibility with that bug.
  24.  }
  25.  
  26. Mandelbrot(XAXIS) {; Mark Peterson
  27.   ; Classical fractal showing LastSqr speedup
  28.   z = Pixel, z = Sqr(z):  ; Start with z**2 to initialize LastSqr
  29.    z = z + Pixel
  30.    z = Sqr(z)
  31.     LastSqr <= 4      ; Use LastSqr instead of recalculating
  32.   }
  33.  
  34. Dragon (ORIGIN) {; Mark Peterson
  35.   z = Pixel:
  36.    z = sqr(z) + (-0.74543, 0.2),
  37.     |z| <= 4
  38.   }
  39.  
  40. Daisy (ORIGIN) {; Mark Peterson
  41.   z = pixel:
  42.    z = z*z + (0.11031, -0.67037),
  43.     |z| <= 4
  44.   }
  45.  
  46. InvMandel (XAXIS) {; Mark Peterson
  47.   c = z = 1 / pixel:
  48.    z = sqr(z) + c;
  49.     |z| <= 4
  50.   }
  51.  
  52. DeltaLog(XAXIS) {; Mark Peterson
  53.   z = pixel, c = log(pixel):
  54.    z = sqr(z) + c,
  55.     |z| <= 4
  56.   }
  57.  
  58. Newton4(XYAXIS) {; Mark Peterson
  59.   ; Note that floating-point is required to make this compute accurately
  60.   z = pixel, Root = 1:
  61.    z3 = z*z*z;
  62.    z4 = z3 * z;
  63.    z = (3 * z4 + Root) / (4 * z3);
  64.     .004 <= |z4 - Root|
  65.   }
  66.  
  67. comment {
  68.    The following are from Chris Green:
  69.    These fractals all use Newton's or Halley's formula for approximation
  70.    of a function.  In all of these fractals, p1 real is the "relaxation
  71.    coefficient". A value of 1 gives the conventional newton or halley
  72.    iteration. Values <1 will generally produce less chaos than values >1.
  73.    1-1.5 is probably a good range to try.  P1 imag is the imaginary component
  74.    of the relaxation coefficient, and should be zero but maybe a small
  75.    non-zero value will produce something interesting. Who knows?
  76.    For more information on Halley maps, see "Computers, Pattern, Chaos,
  77.    and Beauty" by Pickover.
  78.    }
  79.  
  80. Halley (XYAXIS) {; Chris Green. Halley's formula applied to x^7-x=0.
  81.   ; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
  82.   ; Setting P1 to 1 creates the picture on page 277 of Pickover's book
  83.   z=pixel:
  84.    z5=z*z*z*z*z;
  85.    z6=z*z5;
  86.    z7=z*z6;
  87.    z=z-p1*((z7-z)/ ((7.0*z6-1)-(42.0*z5)*(z7-z)/(14.0*z6-2))),
  88.     0.0001 <= |z7-z|
  89.   }
  90.  
  91. CGhalley (XYAXIS) {; Chris Green -- Halley's formula
  92.   ; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
  93.   z=(1,1):
  94.    z5=z*z*z*z*z;
  95.    z6=z*z5;
  96.    z7=z*z6;
  97.    z=z-p1*((z7-z-pixel)/ ((7.0*z6-1)-(42.0*z5)*(z7-z-pixel)/(14.0*z6-2))),
  98.     0.0001 <= |z7-z-pixel|
  99.   }
  100.  
  101. halleySin (XYAXIS) {; Chris Green. Halley's formula applied to sin(x)=0.
  102.   ; Use floating point.
  103.   ; P1 real = 0.1 will create the picture from page 281 of Pickover's book.
  104.   z=pixel:
  105.    s=sin(z), c=cos(z)
  106.    z=z-p1*(s/(c-(s*s)/(c+c))),
  107.     0.0001 <= |s|
  108.   }
  109.  
  110. NewtonSinExp (XAXIS) {; Chris Green
  111.   ; Newton's formula applied to sin(x)+exp(x)-1=0.
  112.   ; Use floating point.
  113.   z=pixel:
  114.    z1=exp(z)
  115.    z2=sin(z)+z1-1
  116.    z=z-p1*z2/(cos(z)+z1),
  117.     .0001 < |z2|
  118.   }
  119.  
  120. CGNewton3 {; Chris Green -- A variation on newton iteration.
  121.   ; The initial guess is fixed at (1,1), but the equation solved
  122.   ; is different at each pixel ( x^3-pixel=0 is solved).
  123.   ; Use floating point.
  124.   ; Try P1=1.8.
  125.   z=(1,1):
  126.    z2=z*z;
  127.    z3=z*z2;
  128.    z=z-p1*(z3-pixel)/(3.0*z2),
  129.     0.0001 < |z3-pixel|
  130.   }
  131.  
  132. HyperMandel {; Chris Green.
  133.   ; A four dimensional version of the mandelbrot set.
  134.   ; Use P1 to select which two-dimensional plane of the
  135.   ; four dimensional set you wish to examine.
  136.   ; Use floating point.
  137.   a=(0,0),b=(0,0):
  138.    z=z+1
  139.    anew=sqr(a)-sqr(b)+pixel
  140.    b=2.0*a*b+p1
  141.    a=anew,
  142.     |a|+|b| <= 4
  143.   }
  144.  
  145.  
  146. MTet (XAXIS) {; Mandelbrot form 1 of the Tetration formula --Lee Skinner
  147.   z = pixel:
  148.    z = (pixel ^ z) + pixel,
  149.     |z| <= (P1 + 3)
  150.   }
  151.  
  152. AltMTet(XAXIS) {; Mandelbrot form 2 of the Tetration formula --Lee Skinner
  153.   z = 0:
  154.    z = (pixel ^ z) + pixel,
  155.     |z| <= (P1 + 3)
  156.   }
  157.  
  158. JTet (XAXIS) {; Julia form 1 of the Tetration formula --Lee Skinner
  159.   z = pixel:
  160.    z = (pixel ^ z) + P1,
  161.     |z| <= (P2 + 3)
  162.   }
  163.  
  164. AltJTet (XAXIS) {; Julia form 2 of the Tetration formula --Lee Skinner
  165.   z = P1:
  166.    z = (pixel ^ z) + P1,
  167.     |z| <= (P2 + 3)
  168.   }
  169.  
  170. Cubic (XYAXIS) {; Lee Skinner
  171.   p = pixel, test = p1 + 3,
  172.   t3 = 3*p, t2 = p*p,
  173.   a = (t2 + 1)/t3, b = 2*a*a*a + (t2 - 2)/t3,
  174.   aa3 = a*a*3, z = 0 - a :
  175.    z = z*z*z - aa3*z + b,
  176.     |z| < test
  177.  }
  178.  
  179. { The following are from Lee Skinner, have been partially generalized. }
  180.  
  181. Fzppfnre  {; Lee Skinner
  182.   z = pixel, f = 1./(pixel):
  183.    z = fn1(z) + f,
  184.     |z| <= 50
  185.   }
  186.  
  187. Fzppfnpo  {; Lee Skinner
  188.   z = pixel, f = (pixel)^(pixel):
  189.    z = fn1(z) + f,
  190.     |z| <= 50
  191.   }
  192.  
  193. Fzppfnsr  {; Lee Skinner
  194.   z = pixel, f = (pixel)^.5:
  195.    z = fn1(z) + f,
  196.     |z| <= 50
  197.   }
  198.  
  199. Fzppfnta  {; Lee Skinner
  200.   z = pixel, f = tan(pixel):
  201.    z = fn1(z) + f,
  202.     |z|<= 50
  203.   }
  204.  
  205. Fzppfnct  {; Lee Skinner
  206.   z = pixel, f = cos(pixel)/sin(pixel):
  207.    z = fn1(z) + f,
  208.     |z|<= 50
  209.   }
  210.  
  211. Fzppfnse  {; Lee Skinner
  212.   z = pixel, f = 1./sin(pixel):
  213.    z = fn1(z) + f,
  214.     |z| <= 50
  215.   }
  216.  
  217. Fzppfncs  {; Lee Skinner
  218.   z = pixel, f = 1./cos(pixel):
  219.    z = fn1(z) + f,
  220.     |z| <= 50
  221.   }
  222.  
  223. Fzppfnth  {; Lee Skinner
  224.   z = pixel, f = tanh(pixel):
  225.    z = fn1(z)+f,
  226.     |z|<= 50
  227.   }
  228.  
  229. Fzppfnht  {; Lee Skinner
  230.   z = pixel, f = cosh(pixel)/sinh(pixel):
  231.    z = fn1(z)+f,
  232.     |z|<= 50
  233.   }
  234.  
  235. Fzpfnseh  {; Lee Skinner
  236.   z = pixel, f = 1./sinh(pixel):
  237.    z = fn1(z) + f,
  238.     |z| <= 50
  239.   }
  240.  
  241. Fzpfncoh  {; Lee Skinner
  242.   z = pixel, f = 1./cosh(pixel):
  243.    z = fn1(z) + f,
  244.     |z| <= 50
  245.   }
  246.  
  247.  
  248. { The following resulted from a FRACTINT bug. Version 13 incorrectly
  249.   calculated Spider (see above). We fixed the bug, and reverse-engineered
  250.   what it was doing to Spider - so here is the old "spider" }
  251.  
  252. Wineglass(XAXIS) {; Pieter Branderhorst
  253.   c = z = pixel:
  254.    z = z * z + c
  255.    c = (1+flip(imag(c))) * real(c) / 2 + z,
  256.     |z| <= 4 }
  257.  
  258.  
  259. { The following is from Scott Taylor.
  260.   Scott says they're "Dog" because the first one he looked at reminded him
  261.   of a hot dog. This was originally several fractals, we have generalized it. }
  262.  
  263. FnDog(XYAXIS)  {; Scott Taylor
  264.   z = Pixel, b = p1+2:
  265.    z = fn1( z ) * pixel,
  266.     |z| <= b
  267.   }
  268.  
  269. Ent {; Scott Taylor
  270.   ; Try params=.5/.75 and the first function as exp.
  271.   ; Zoom in on the swirls around the middle.  There's a
  272.   ; symmetrical area surrounded by an asymmetric area.
  273.   z = Pixel, y = fn1(z), base = log(p1):
  274.    z = y * log(z)/base,
  275.     |z| <= 4
  276.   }
  277.  
  278. Ent2 {; Scott Taylor
  279.   ; try params=2/1, functions=cos/cosh, potential=255/355
  280.   z = Pixel, y = fn1(z), base = log(p1):
  281.    z = fn2( y * log(z) / base ),
  282.     |z| <= 4
  283.   }
  284.  
  285. { From Kevin Lee: }
  286.  
  287. LeeMandel1(XYAXIS) {; Kevin Lee
  288.   z=Pixel:
  289. ;; c=sqr(pixel)/z, c=z+c, z=sqr(z),  this line was an error in v16
  290.    c=sqr(pixel)/z, c=z+c, z=sqr(c),
  291.     |z|<4
  292.   }
  293.  
  294. LeeMandel2(XYAXIS) {; Kevin Lee
  295.   z=Pixel:
  296.    c=sqr(pixel)/z, c=z+c, z=sqr(c*pixel),
  297.     |z|<4
  298.    }
  299.  
  300. LeeMandel3(XAXIS) {; Kevin Lee
  301.   z=Pixel, c=Pixel-sqr(z):
  302.    c=Pixel+c/z, z=c-z*pixel,
  303.     |z|<4
  304.   }
  305.  
  306. { These are a few of the examples from the book,
  307.   Fractal Creations, by Tim Wegner and Mark Peterson. }
  308.  
  309. MyFractal {; Fractal Creations example
  310.   c = z = 1/pixel:
  311.    z = sqr(z) + c;
  312.     |z| <= 4
  313.   }
  314.  
  315. Bogus1 {; Fractal Creations example
  316.   z = 0; z = z + * 2,
  317.    |z| <= 4 }
  318.  
  319. MandelTangent {; Fractal Creations example (revised for v.16)
  320.   z = pixel:
  321.    z = pixel * tan(z),
  322.     |real(z)| < 32
  323.   }
  324.  
  325. Mandel3 {; Fractal Creations example
  326.   z = pixel, c = sin(z):
  327.    z = (z*z) + c;
  328.    z = z * 1/c;
  329.     |z| <= 4;
  330.    }
  331.  
  332. { These are from: "AKA MrWizard W. LeRoy Davis;SM-ALC/HRUC"
  333.           davisl@sm-logdis1-aflc.af.mil
  334.   The first 3 are variations of:
  335.                z
  336.        gamma(z) = (z/e) * sqrt(2*pi*z) * R        }
  337.  
  338. Sterling(XAXIS) {; davisl
  339.   z = Pixel:
  340.    z = ((z/2.7182818)^z)/sqr(6.2831853*z),
  341.     |z| <= 4
  342.   }
  343.  
  344. Sterling2(XAXIS) {; davisl
  345.   z = Pixel:
  346.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) + pixel,
  347.     |z| <= 4
  348.   }
  349.  
  350. Sterling3(XAXIS) {; davisl
  351.   z = Pixel:
  352.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) - pixel,
  353.     |z| <= 4
  354.   }
  355.  
  356. PsudoMandel(XAXIS) {; davisl - try center=0,0/magnification=28
  357.   z = Pixel:
  358.    z = ((z/2.7182818)^z)*sqr(6.2831853*z) + pixel,
  359.     |z| <= 4
  360.   }
  361.  
  362. { These are the original "Richard" types sent by Jm Richard-Collard. Their
  363.   generalizations are tacked on to the end of the "Jm" list below, but
  364.   we felt we should keep these around for historical reasons.}
  365.  
  366. Richard1 (XYAXIS) {; Jm Richard-Collard
  367.   z = pixel:
  368.    sq=z*z, z=(sq*sin(sq)+sq)+pixel,
  369.     |z|<=50
  370.   }
  371.  
  372. Richard2 (XYAXIS) {; Jm Richard-Collard
  373.   z = pixel:
  374.    z=1/(sin(z*z+pixel*pixel)),
  375.     |z|<=50
  376.   }
  377.  
  378. Richard3 (XAXIS) {; Jm Richard-Collard
  379.   z = pixel:
  380.    sh=sinh(z), z=(1/(sh*sh))+pixel,
  381.     |z|<=50
  382.   }
  383.  
  384. Richard4 (XAXIS) {; Jm Richard-Collard
  385.   z = pixel:
  386.    z2=z*z, z=(1/(z2*cos(z2)+z2))+pixel,
  387.     |z|<=50
  388.   }
  389.  
  390. Richard5 (XAXIS) {; Jm Richard-Collard
  391.   z = pixel:
  392.    z=sin(z*sinh(z))+pixel,
  393.     |z|<=50
  394.   }
  395.  
  396. Richard6 (XYAXIS) {; Jm Richard-Collard
  397.   z = pixel:
  398.    z=sin(sinh(z))+pixel,
  399.     |z|<=50
  400.   }
  401.  
  402. Richard7 (XAXIS) {; Jm Richard-Collard
  403.   z=pixel:
  404.    z=log(z)*pixel,
  405.     |z|<=50
  406.   }
  407.  
  408. Richard8 (XYAXIS) {; Jm Richard-Collard
  409.   ; This was used for the "Fractal Creations" cover
  410.   z=pixel,sinp = sin(pixel):
  411.    z=sin(z)+sinp,
  412.     |z|<=50
  413.   }
  414.  
  415. Richard9 (XAXIS) {; Jm Richard-Collard
  416.   z=pixel:
  417.    sqrz=z*z, z=sqrz + 1/sqrz + pixel,
  418.     |z|<=4
  419.   }
  420.  
  421. Richard10(XYAXIS) {; Jm Richard-Collard
  422.   z=pixel:
  423.    z=1/sin(1/(z*z)),
  424.     |z|<=50
  425.   }
  426.  
  427. Richard11(XYAXIS) {; Jm Richard-Collard
  428.   z=pixel:
  429.    z=1/sinh(1/(z*z)),
  430.     |z|<=50
  431.   }
  432.  
  433. { These types are generalizations of types sent to us by the French
  434.   mathematician Jm Richard-Collard. If we hadn't generalized them
  435.   there would be --ahhh-- quite a few. With 11 possible values for
  436.   each fn variable,Jm_03, for example, has 14641 variations! }
  437.  
  438. Jm_01 {; generalized Jm Richard-Collard type
  439.   z=pixel,t=p1+4:
  440.    z=(fn1(fn2(z^pixel)))*pixel,
  441.     |z|<=t
  442.   }
  443.  
  444. Jm_02 {; generalized Jm Richard-Collard type
  445.   z=pixel,t=p1+4:
  446.    z=(z^pixel)*fn1(z^pixel),
  447.     |z|<=t
  448.   }
  449.  
  450. Jm_03 {; generalized Jm Richard-Collard type
  451.   z=pixel,t=p1+4:
  452.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))*pixel,
  453.     |z|<=t
  454.   }
  455.  
  456. Jm_03a {; generalized Jm Richard-Collard type
  457.   z=pixel,t=p1+4:
  458.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))+pixel,
  459.     |z|<=t
  460.   }
  461.  
  462. Jm_04 {; generalized Jm Richard-Collard type
  463.   z=pixel,t=p1+4:
  464.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel)),
  465.     |z|<=t
  466.   }
  467.  
  468. Jm_05 {; generalized Jm Richard-Collard type
  469.   z=pixel,t=p1+4:
  470.    z=fn1(fn2((z^pixel))),
  471.     |z|<=t
  472.   }
  473.  
  474. Jm_06 {; generalized Jm Richard-Collard type
  475.   z=pixel,t=p1+4:
  476.    z=fn1(fn2(fn3((z^z)*pixel))),
  477.     |z|<=t
  478.   }
  479.  
  480. Jm_07 {; generalized Jm Richard-Collard type
  481.   z=pixel,t=p1+4:
  482.    z=fn1(fn2(fn3((z^z)*pixel)))*pixel,
  483.     |z|<=t
  484.   }
  485.  
  486. Jm_08 {; generalized Jm Richard-Collard type
  487.   z=pixel,t=p1+4:
  488.    z=fn1(fn2(fn3((z^z)*pixel)))+pixel,
  489.     |z|<=t
  490.   }
  491.  
  492. Jm_09 {; generalized Jm Richard-Collard type
  493.   z=pixel,t=p1+4:
  494.    z=fn1(fn2(fn3(fn4(z))))+pixel,
  495.     |z|<=t
  496.   }
  497.  
  498. Jm_10 {; generalized Jm Richard-Collard type
  499.   z=pixel,t=p1+4:
  500.    z=fn1(fn2(fn3(fn4(z)*pixel))),
  501.     |z|<=t
  502.   }
  503.  
  504. Jm_11 {; generalized Jm Richard-Collard type
  505.   z=pixel,t=p1+4:
  506.    z=fn1(fn2(fn3(fn4(z)*pixel)))*pixel,
  507.     |z|<=t
  508.   }
  509.  
  510. Jm_11a {; generalized Jm Richard-Collard type
  511.   z=pixel,t=p1+4:
  512.    z=fn1(fn2(fn3(fn4(z)*pixel)))+pixel,
  513.     |z|<=t
  514.   }
  515.  
  516. Jm_12 {; generalized Jm Richard-Collard type
  517.   z=pixel,t=p1+4:
  518.    z=fn1(fn2(fn3(z)*pixel)),
  519.     |z|<=t
  520.   }
  521.  
  522. Jm_13 {; generalized Jm Richard-Collard type
  523.   z=pixel,t=p1+4:
  524.    z=fn1(fn2(fn3(z)*pixel))*pixel,
  525.     |z|<=t
  526.   }
  527.  
  528. Jm_14 {; generalized Jm Richard-Collard type
  529.   z=pixel,t=p1+4:
  530.    z=fn1(fn2(fn3(z)*pixel))+pixel,
  531.     |z|<=t
  532.   }
  533.  
  534. Jm_15 {; generalized Jm Richard-Collard type
  535.   z=pixel,t=p1+4:
  536.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))*pixel,
  537.     |z|<=t
  538.   }
  539.  
  540. Jm_16 {; generalized Jm Richard-Collard type
  541.   z=pixel,t=p1+4:
  542.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))+pixel,
  543.     |z|<=t
  544.   }
  545.  
  546. Jm_17 {; generalized Jm Richard-Collard type
  547.   z=pixel,t=p1+4:
  548.    z=fn1(z)*pixel*fn2(fn3(z)),
  549.     |z|<=t
  550.   }
  551.  
  552. Jm_18 {; generalized Jm Richard-Collard type
  553.   z=pixel,t=p1+4:
  554.    z=fn1(z)*pixel*fn2(fn3(z)*pixel),
  555.     |z|<=t
  556.   }
  557.  
  558. Jm_19 {; generalized Jm Richard-Collard type
  559.   z=pixel,t=p1+4:
  560.    z=fn1(z)*pixel*fn2(fn3(z)+pixel),
  561.     |z|<=t
  562.   }
  563.  
  564. Jm_20 {; generalized Jm Richard-Collard type
  565.   z=pixel,t=p1+4:
  566.    z=fn1(z^pixel),
  567.     |z|<=t
  568.   }
  569.  
  570. Jm_21 {; generalized Jm Richard-Collard type
  571.   z=pixel,t=p1+4:
  572.    z=fn1(z^pixel)*pixel,
  573.     |z|<=t
  574.   }
  575.  
  576. Jm_22 {; generalized Jm Richard-Collard type
  577.   z=pixel,t=p1+4:
  578.    sq=fn1(z), z=(sq*fn2(sq)+sq)+pixel,
  579.     |z|<=t
  580.   }
  581.  
  582. Jm_23 {; generalized Jm Richard-Collard type
  583.   z=pixel,t=p1+4:
  584.    z=fn1(fn2(fn3(z)+pixel*pixel)),
  585.     |z|<=t
  586.   }
  587.  
  588. Jm_24 {; generalized Jm Richard-Collard type
  589.   z=pixel,t=p1+4:
  590.    z2=fn1(z), z=(fn2(z2*fn3(z2)+z2))+pixel,
  591.     |z|<=t
  592.   }
  593.  
  594. Jm_25 {; generalized Jm Richard-Collard type
  595.   z=pixel,t=p1+4:
  596.    z=fn1(z*fn2(z)) + pixel,
  597.     |z|<=t
  598.   }
  599.  
  600. Jm_26 {; generalized Jm Richard-Collard type
  601.   z=pixel,t=p1+4:
  602.    z=fn1(fn2(z)) + pixel,
  603.     |z|<=t
  604.   }
  605.  
  606. Jm_27 {; generalized Jm Richard-Collard type
  607.   z=pixel,t=p1+4:
  608.    sqrz=fn1(z), z=sqrz + 1/sqrz + pixel,
  609.     |z|<=t
  610.   }
  611.  
  612. Jm_ducks(XAXIS) {; Jm Richard-Collard
  613.   ; Not so ugly at first glance and lot of corners to zoom in.
  614.   ; try this: corners=-1.178372/-0.978384/-0.751678/-0.601683
  615.   z=pixel,tst=p1+4,t=1+pixel:
  616.    z=sqr(z)+t,
  617.     |z|<=tst
  618.   }
  619.  
  620. Gamma(XAXIS)={ ; first order gamma function from Prof. Jm
  621.   ; "It's pretty long to generate even on a 486-33 comp but there's a lot
  622.   ; of corners to zoom in and zoom and zoom...beautiful pictures :)"
  623.   z=pixel,twopi=6.283185307179586,r=10:
  624.    z=(twopi*z)^(0.5)*(z^z)*exp(-z)+pixel
  625.     |z|<=r
  626.   }
  627.  
  628. ZZ(XAXIS) { ; Prof Jm using Newton-Raphson method
  629.   ; use floating point with this one
  630.   z=pixel,solution=1:
  631.    z1=z^z;
  632.    z2=(log(z)+1)*z1;
  633.    z=z-(z1-1)/z2 ,
  634.     0.001 <= |solution-z1|
  635.   }
  636.  
  637. ZZa(XAXIS) { ; Prof Jm using Newton-Raphson method
  638.   ; use floating point with this one
  639.   z=pixel,solution=1:
  640.    z1=z^(z-1);
  641.    z2=(((z-1)/z)+log(z))*z1;
  642.    z=z-((z1-1)/z2) ,
  643.     .001 <= |solution-z1|
  644.   }
  645.  
  646. MandelXAxis(XAXIS) {    ; for Transparent3D
  647.   z = zt,        ; Define Julia axes as depth/time and the
  648.   c = xy:        ;   Mandelbrot axes as width/height for each slice.
  649.             ;   This corresponds to Mandelbrot axes as
  650.             ;   height/depth and the Julia axes as width
  651.             ;   time for the 3D image.
  652.    z = Sqr(z) + c
  653.     LastSqr <= 4;
  654.   }
  655.  
  656. OldJulibrot(ORIGIN) {            ; for Transparent3D
  657.   z = real(zt) + flip(imag(xy)),    ; These settings coorespond to the
  658.   c = imag(zt) + flip(real(xy)):    ;    Julia axes as height/width and
  659.                     ;    the Mandelbrot axes as time/depth
  660.                     ;    for the 3D image.
  661.    z = Sqr(z) + c
  662.     LastSqr <= 4;
  663.   }
  664.